﻿
using CSharpConsoleTestSolution.Demo;

/**
 * https://www.bilibili.com/video/BV1wx411K7rb
 * C#语言入门详解
 * 
 * C#语言入门详解搬运，随youtube上进度更新。
 * 刘老师的C#视频教程到30集就告一段落了，感谢刘老师在这5年间的付出。能上youtube的同学可以去刘老师的主页观看，https://www.youtube.com/channel/UCmvAggiJGwJGSzAtqFRBQ7g
 *
 *
 * 
 * 据查资料:
 * JDK => .NET Framework / .NET Core / .NET SDK
 * Java => C#
 * JVM => CLR
 * JVM 上有 Java、Scala、JPython 等多种语言
 * CLR 上有 C#、F#、IronPython 等多种语言
 *
 * .NET 是开发平台(核心特点是跨平台，如 Windows、Linux、macOS、iOS、watchOS 和 Docker 等)
 * .NET Framework 是在 .NET 平台上针对 Windows 系统实现的开发框架
 * .NET Core / .NET 是在 .NET 平台上实现的 支持多操作系统的 跨平台开发框架
 *
 * 你可以使用多种语言来编写 .NET 应用程序，主流的语言有：C#, F# 和 Visual Basic。
 *
 * .NET Framework第一个版本发布于2002年，.NETCore第一个版本在2016年推出
 *
 * .NET Core的与.NET Framework对比，具有以下几个优势。跨平台。可以在window、Linux、macOS平台上运行；
 *
 * 
 * 需求或场景                                        推荐的.NET平台
 * 需要高性能稳定，没有UI界面                       .NET Core (性能更好，支持Docker容器)
 * 命令行上的大量操作                                .NET Core (支持得更好)
 * 有跨平台的需求                                      .NET Core
 * 使用微服务                                            .NET Core (为当下需求而设计)
 * 以用户界面为中心的Web应用程序                              .NET Framework (直到.NET Core赶上之前)
 * 使用Windows窗体和WPF的Windows客户端应用程序                   .NET Framework (已有预先配置的环境和系统)
 * 需要马上构建布署稳定的版本                                      .NET Framework (更成熟)
 * 存在经验丰富的.Net团队，但时间不是问题，实验是可以接受的，不急于部署 .NET Core (是.NET的未来，有学习曲线)
 */
namespace CSharpConsoleTestSolution {
    internal class Program {
        public static void Main(string[] args) {
            Call(31);
        }

        /**
         * @param pos 第几课
         */
        private static void Call(int pos)
        {
            switch (pos)
            {
                case 1:
                case 2:
                case 3:
                case 4:
                case 5:
                case 6:
                    //P6 详解类型、变量与对象 _1,    为何要写成 200==x
                    P6_Type_Variable_Object.typeVariable();
                    break;
                case 7:    
                case 8:    
                case 9:    
                case 10:    
                    //P10 操作符详解_1,    operator 操作符示例
                    P10_Operator1.operator_exam();
                    //                    delegate 方法委托
                    P10_Operator1.delegate_Action_exam();
                    //                    Dictionary 字典类
                    P10_Operator1.Dictionary_exam();
                    //                    typeof() 操作符
                    P10_Operator1.typeof_exam();
                    //                    default() 操作符
                    P10_Operator1.default_exam();
                    break;
                case 11:   
                    //                    隐式构造器 new {}
                    P11_Operator2.hidden_constructor_exam();
                    //                    子类隐藏父类方法(new, 编程中不常见)
                    P11_Operator2.hidden_parent_method_exam();
                    //                    打印二进制&溢出检查( checked(x) )
                    P11_Operator2.print_binary_checked_exam();
                    //                    delegate(操作符[一般不用于操作符,已被lambda替代] & 声明委托的数据类型)
                    P11_Operator2.delegate_exam();
                    //                    sizeof, 获取对象在内存中所占尺寸( sizeof(x) )
                    P11_Operator2.sizeof_exam();
                    //                    -> 指针 ( pStu->Score = 100; )
                    P11_Operator2.pointer_exam();
                    //                    一元操作符 ( +, -, !, ~, ++x, --x, (T)x, await, &x, *x )
                    P11_Operator2._1yuan_exam();
                    break;
                case 12:
                    //                    Parse 和 Convert, 数据类型转换
                    P12_Operator3.parse_convert();
                    //              explicit operator 显式类型转换
                    P12_Operator3.explicit_operator_exam();
                    //            implicit operator 隐式类型转换
                    P12_Operator3.implicit_operator_exam();
                    //            divide 除法(double可除0)
                    P12_Operator3.divide();
                    //            字符串比较
                    P12_Operator3.compare();
                    //            is, as
                    P12_Operator3.is_as();
                    //            ? 可空, ?? 判断是否可空
                    P12_Operator3.nullable_isnull();
                    //            条件操作符 ? x : y
                    P12_Operator3.conditional_operator();
                    break;
                case 13:
                case 14:
                case 15:
                    //              块语句里的 goto
                    P15_Expression.goto_exam();
                    //              switch 里的 goto
                    P15_Expression.switch_goto();
                    //              catch 无参
                    P15_Expression.try_catch();
                    //              catch 多种类型, finally, throw
                    P15_Expression.try_catch2();
                    break;
                case 16:
                    //              continue 语句
                    P16_Expression.continue_exam();
                    //              Enumerator 迭代器, 枚举器, 计数器
                    P16_Expression.Enumerator();
                    break;
                case 17:
                    //              静态构造器
                    P17_Field_Attribute_Indexer_Const.static_Constructor();
                    //              readonly(相当于java的final) 只读, 只有1次赋值机会
                    P17_Field_Attribute_Indexer_Const.readonly_test();
                    //              字段的属性
                    P17_Field_Attribute_Indexer_Const.field_property();
                    //              字段属性 的 简略声明
                    P17_Field_Attribute_Indexer_Const.field_property_simple_announcement();
                    //              字段只读
                    P17_Field_Attribute_Indexer_Const.field_getter_only();
                    //              自定义 索引器(indexer + Enter)
                    P17_Field_Attribute_Indexer_Const.indexer_exam();
                    //              常量 const
                    P17_Field_Attribute_Indexer_Const.const_exam();
                    break;
                case 18:
                    //              1.传值参数
                    P18_Params.value_params();
                    //              2.引用参数: ref 修饰的参数(可为null), 不会对传入的参数创建副本!
                    P18_Params.ref_params();
                    //              3.输出参数: out 修饰的参数(可为null), 输出形参不创建新的存储位置.
                    P18_Params.out_params();
                    //              4.数组参数: params 修饰的数组参数(params object[] args), 参数个数可变
                    P18_Params.params_params();
                    //              5.具名参数(参数的位置不再受约束), Method4(age: 213, name: "张三");
                    P18_Params.name_params();
                    //              6.可选参数(参数有默认值, ∴可选), Method5(string name, int age = 23);
                    P18_Params.optional_params();
                    //              7.扩展方法(this参数)
                    P18_Params.this_params_extension_method();
                    //              7.扩展方法(this参数)
                    P18_Params.linq_params();
                    break;
                case 19:
                    //              1.Action 委托
                    P19_delegate.Action_delegate();
                    //              2.Func 委托
                    P19_delegate.Func_delegate();
                    //              3.Predicate 委托: bool (参数x1) { ... }
                    P19_delegate.Predicate_delegate();
                    //              4.自定义委托: delegate double Calc(double x, double y)
                    P19_delegate.Custom_delegate();
                    //              5.委托的一般使用
                    P19_delegate.usage_delegate();
                    //               6.委托的高级使用: 多播( multicast) 委托
                    P19_delegate.multicast_delegate();
                    //               7.委托的高级使用: 隐式异步调用
                    P19_delegate.hide_async_delegate();
                    //               8.委托的高级使用: 显式异步调用
                    P19_delegate.show_async_delegate();
                    //               9.静态方法 委托
                    P19_delegate.static_delegate();
                    break;
                case 20:
                case 21:
                    //              1.Timber 事件, 时间: 17:40
                    P21_Event.timer_event();
                    break;
                case 22:
                    //              1.事件的完整声明
                    P22_LinQ.event_complete_statement();
                    //              2.事件的简略声明
                    P22_LinQ.event_brief_statement();
                    //              3.有了委托字段/属性，为什么还需要事件 ?
                    P22_LinQ.notice();
                    //              4.EventHandler 委托, 时间: 43:35
                    P22_LinQ.EventHandler_delegate();
                    //              5.事件 与 委托 的关系, 时间: 57:06
                    P22_LinQ.event_delegate_relationship();
                    break;
                case 23:
                    //              1.Lambda 表达式
                    P23_LinQ.Lambda_expression();
                    //              2.LinQ: .NET Language Integrated Query
                    P23_LinQ.LinQ_test();
                    break;
                case 24:
                    //              1.构造方法 & 析构器
                    P24_class.constructor_test();
                    //              3.反射 & 动态编程(dynamic): Activator.CreateInstance
                    P24_class.reflect_test();
                    //              4.静态构造器(必须是空参)
                    P24_class.static_constructor_test();
                    break;
                case 25:
                    //              1.类的声明与访问级别
                    P25_class_declaration_access.test();
                    break;
                case 26:
                    //              1.类的继承, 类成员的访问控制
                    P26_class_extends_field_access.extends_test();
                    //              2.成员的继承 & 构造方法
                    P26_class_extends_field_access.field_and_constructor();
                    //              3.类成员的访问级别
                    P26_class_extends_field_access.field_access_level();
                    break;
                case 27:
                    //              0.重写 & 多态
                    P27_override_polymorphism.test();
                    //              1.重写 & 多态
                    P27_override_polymorphism.virtual_override_test();
                    break;
                case 28:
                    //              1.抽象类与开闭原则
                    P28_abstract.abstract_test();
                    break;
                case 29:
                    //              1.接口, 依赖反转, 单元测试
                    P29_interface_di_unit_test.unit_test();
                    //              2.单元测试 Moq 框架
                    P29_interface_di_unit_test.unit_Moq();
                    break;
                case 30:
                    //              1.接口隔离: 显式接口实现
                    P30_reflect_di.implement_interface_explicitly();
                    //              2.反射
                    P30_reflect_di.reflection_test();
                    //              3.框架: DependencyInjection
                    P30_reflect_di.DependencyInjection_test();
                    //              4."插件式编程"
                    // P30_reflect_di.plugins_test();
                    //              5.SDK 开发
                    P30_reflect_di.sdk_test();
                    break;
                case 31:
                    //              1.泛型
                    P31_Geniric_partial_enum_structure.Generic_test();
                    //              2.partial 类(public partial class App {}, namespace & className 确保一致)
                    P31_Geniric_partial_enum_structure.partial_test();
                    //              3.enum 枚举
                    P31_Geniric_partial_enum_structure.enum_test();
                    //              4.struct 结构体
                    P31_Geniric_partial_enum_structure.struct_test();
                    break;
                default:
                    break;
            }
        }
    }
}